/*
 * TacticaJavier.java
 *
 */

package futbol.tacticas.concursantes2007.QBits;

import futbol.tacticas.*;
import futbol.tacticas.concursantes.Tactica;

import java.awt.Color;
import java.awt.Point;
import java.util.Vector;

/**
 *
 * @author Javier Alcubierre Villasol
 */
public class TacticaJavier implements Tactica{
	
	private double antx, anty, vel, a, b, m, x, y;
	private double porteroX = -152, porteroY;	
	private static int N_DEFENSAS = 3;
	private static int N_CENTROS = 3;
	
	private int fuerza[] = {4,6,6,6,6,6,6,7,7,7,6};
	
	//ordenes a los jugadores {orden, parametro1, parametro2, parametro3} 
	//ordenes:
	//0 - tira a puerta
	//1 - tira a x = par1 y = par2
	//2 - pasa a jugador = par1
	//3 - muevete a x = par1 y = par2 y tira a puerta
	//4 - muevete a x = par1 y = par2 y pasa a par3
	//5 - muevete a x = par1 y = par2
	//6 - ve a tu posicion original
	//7 - no hagas nada	
	private double ordenes[][] = new double[11][4];
	
		
	private int jugPos[][]={
		{-152,0},
		{-90,-60},
		{-90,0},
		{-90,60},        
		{5,60},
		{5,0},
		{5,-60},
		{90,60},
		{90,0},
		{90,-60}, 
		{145,0}
	};
	    
	private int jugPosInicial[][]={
		{-152,0},
		{-90,-50},
		{-90,0},
		{-90,50},         
		{160,30},
		{160,10},
		{160,-30},
		{160,60},
		{160,0},
		{160,-60},
		{160,0}		
	};


	public String getNombre(){
		return "QBits";
	}
	    
	public Color getColor1(){
		return Color.black;
	}
	    
	public Color getColor2(){
		return Color.black;
	}
	    
	public Color getColorNumero(){
		return Color.white;
	}
	    
	public int getFuerza(int n){
		//System.out.println("getFuerza "+ n);	
		return fuerza[n];
	}
	
	public int getXInicial(int n){
		//Cuando se llama por primera vez por saque a getXInicial se incia la primera orden a los jugadores
		ordenes[n][0] = 6;		
		//System.out.println("getXIncial "+ n);
		return jugPosInicial[n][0];
	}
	    
	public int getYInicial(int n){
		//System.out.println("getYIncial " + n);
		return jugPosInicial[n][1];
	}
    
	public Vector<Comando> getComandos(SituacionJugadores sj){		
		Vector<Comando> comandos=new Vector();
			    
		Point[] jugador = sj.getMisJugadores();
		Point[] rival = sj.getContrario();		
		
		int nRival;
		    
		
		//Calculos geometricos
		Point bola=sj.getBola();
		x = bola.getX();
		y = bola.getY();

		
		vel = Math.sqrt(Math.pow(x - antx,2)  + Math.pow(y - anty, 2));

		//BEGIN Inteligencia del portero		
		porteroX = -152;		
		//Si la pelota esta quieta				
		if((x == antx) && (y == anty)){		
			nRival = sj.getContrarioMasCerca(x, y);
			if((distancia(rival[nRival].getX(), rival[nRival].getY(), x, y) >= distancia(jugador[0].getX(), jugador[0].getY(), x, y)) && (distancia(jugador[0].getX(), jugador[0].getY(), x, y) < 45) && (sj.getMasCercanoDeBola() == 0)){
				porteroX = x;
				porteroY = y;
			}else{
				//m = (rival[nRival].getY())/(rival[nRival].getX()-160);
				m = (y)/(x-160);
				if(Double.isNaN(m))
					m = 1;

				porteroY = ((porteroX - x) * m) + y;
				if((porteroY > 30) || (porteroY < -30))
					porteroY = 0;
			}
		}else{
			//Pelota en movimiento
			m = (anty-y)/(antx-x);
			if(Double.isNaN(m))
				m = 1;

			porteroY = ((porteroX - x) * m) + y;
			//si la pelota va fuera de los palos o va desviada
			if((porteroY > 30) || (porteroY < -30)) {
				nRival = sj.getContrarioMasCerca(x, y);
				//si el portero esta mas cerca que el rival y la pelota esta dentro del area sale a buscarla y la golpea
				if((distancia(rival[nRival].getX(), rival[nRival].getY(), x, y) >= distancia(jugador[0].getX(), jugador[0].getY(), x, y)) & (x > -100) && (distancia(jugador[0].getX(), jugador[0].getY(), x, y) < 45)){
					porteroX = x;
					porteroY = y;
				}else{										
					//m = (rival[nRival].getY())/(rival[nRival].getX()-160);
					m = (y)/(x-160);
					if(Double.isNaN(m))
						m = 1;

					porteroY = ((porteroX - x) * m) + y;
					if((porteroY > 30) || (porteroY < -30))
						porteroY = 0;
				}
			}
		}
		
		ordenes[0][0] = 5;
		ordenes[0][1] = porteroX;
		ordenes[0][2] = porteroY;		
		//END Inteligencia del portero
		
		
		double antiPorteroX, antiPorteroY;
		int porteroRival;
		
		//BEGIN Inteligencia del anti-portero	
		porteroRival = sj.getContrarioMasCerca(160, 0);
		
		antiPorteroX = 145;		
		//Si la pelota esta quieta				
		if((x == antx) && (y == anty)){		
			if(sj.getMasCercanoDeBola() == 10){
				antiPorteroX = x;
				antiPorteroY = y;
			}else{
				antiPorteroX = rival[porteroRival].getX()-10;
				antiPorteroY = rival[porteroRival].getY();
			}
		}else{
			//Pelota en movimiento
			m = (anty-y)/(antx-x);
			if(Double.isNaN(m))
				m = 1;

			antiPorteroY = ((antiPorteroX - x) * m) + y;
			//si la pelota va fuera de los palos o va desviada
			if((antiPorteroY > 60) || (antiPorteroY < -60)) {
				nRival = sj.getContrarioMasCerca(x, y);
				//si el antiportero esta mas cerca que el rival y la pelota esta dentro del area sale a buscarla y la golpea
				if((distancia(rival[nRival].getX(), rival[nRival].getY(), x, y) >= distancia(jugador[10].getX(), jugador[10].getY(), x, y)) & (x > -100) && (distancia(jugador[10].getX(), jugador[10].getY(), x, y) < 45)){
					antiPorteroX = x;
					antiPorteroY = y;
				}else{										
					//m = (rival[nRival].getY())/(rival[nRival].getX()-160);
					m = (y)/(x-160);
					if(Double.isNaN(m))
						m = 1;

					antiPorteroY = ((antiPorteroX - x) * m) + y;
					if(antiPorteroY > 50) 
						antiPorteroY = 50;
					 if(antiPorteroY < -50)
						antiPorteroY = -50;
						 
				}
			}
		}
		
		ordenes[10][0] = 5;
		ordenes[10][1] = antiPorteroX;
		ordenes[10][2] = antiPorteroY;
		comandos.add(new ComandoTiroAPuerta(10,0));
		//END Inteligencia del anti-portero		
		
		
		
		//BEGIN Defensa	
		//El que este mas cerca de su punto de interseccion intersecta la pelota
		int defensaIntersecta = 0;
		double distanciaIntersecta = 1000;
		double intersectaX = 0, intersectaY = 0;
		double distanciaDefensaActual1, distanciaDefensaActual2;		
		double defensaY = 0;
		double defensaX = 0;
		for(int i = 1; i < N_DEFENSAS+1; i++){
			ordenes[i][0] = 6;
			
			if(x < jugador[i].getX()){
				ordenes[i][0] = 4;
				ordenes[i][1] = x;
				ordenes[i][2] = y;				
			}else{
				defensaY = jugador[i].getY();
				defensaX = jugador[i].getX();
				m = (anty-y)/(antx-x);
				if((Double.isNaN(m)) || (m == 0))
					m = 0;
				
				//interseccion en el eje Y
				if(m != 0)
					defensaY = ((jugador[i].getX() - x) * m) + y;
				else
					defensaY = y;
				
				//rebote en los laterales
				if(defensaY < -120)
					defensaY = 0-(120 +(defensaY + 120));
				if(defensaY > 120)
					defensaY = 120 -(defensaY - 120);
				
				distanciaDefensaActual1 = distancia(jugador[i].getX(), jugador[i].getY(), jugador[i].getX(), defensaY);
				
				//interseccion en el eje X				
				if(m != 0)
					defensaX = ((jugador[i].getY() - y)/m)+x;
				else
					defensaX = x;

				
				if(defensaX > -30) 
					defensaX = 10000;
				
				if(defensaX < -160)
					defensaX = 0-(160 +(defensaY + 160));
			

				distanciaDefensaActual2 = distancia(jugador[i].getX(), jugador[i].getY(), defensaX, jugador[i].getY());
				/*//System.out.println("Analizando defensa " + i + " m: " + m + " defensaX " + defensaX + " defensaY " + defensaY);
				//System.out.println(" X " + jugador[i].getX() + " Y " + jugador[i].getY());
				//System.out.println(" DistanciaDefensa1: "+i + " = " +distanciaDefensaActual1 + " DistanciaDefensa2: " + distanciaDefensaActual2 +" actual " + distanciaIntersecta);*/
				
				
				if(distanciaDefensaActual2 < distanciaDefensaActual1){
					if(distanciaDefensaActual2 < distanciaIntersecta){
						intersectaX = jugador[i].getX();
						intersectaY = defensaY;
						distanciaIntersecta = distanciaDefensaActual2;
						defensaIntersecta = i;
					}
				}else{
					if(distanciaDefensaActual1 < distanciaIntersecta){
						intersectaX = defensaX;
						intersectaY = jugador[i].getY();
						distanciaIntersecta = distanciaDefensaActual1;
						defensaIntersecta = i;
					}	
				}								
			}
		}
		if((defensaIntersecta != 0) && (distanciaIntersecta < 100) 
		&& (intersectaX <= 0) && (intersectaX >= -160) 
		&& (intersectaY <= 120) && (intersectaY >= -120))  {
			ordenes[defensaIntersecta][0] = 5;
			ordenes[defensaIntersecta][1] = intersectaX;
			ordenes[defensaIntersecta][2] = intersectaY;					
		}		

		int contrarioCubierto[]= {0,0,0,0,0,0,0,0,0,0,0};

		//vemos si hay algun antiPorteroRival y lo cubrimos con el defensa central
		int contrarioAntiPortero = sj.getMiJugadorMasCerca(-160, 0);
		if(distancia(-160, 0, rival[contrarioAntiPortero].getX(), rival[contrarioAntiPortero].getY()) <= 40){
			ordenes[2][0] = 5;
			ordenes[2][1] = rival[contrarioAntiPortero].getX()+10;
			ordenes[2][2] = rival[contrarioAntiPortero].getY();					
			contrarioCubierto[contrarioAntiPortero] = 1;
		}else{
			contrarioAntiPortero = -1;			
		}
			
					
		int contrario, jug_mas_cerca;
		for(int i = 1; i < N_DEFENSAS+1; i++){				
			if(i == defensaIntersecta)
				continue;
			if((contrarioAntiPortero != -1) && (i == 2))
				continue;
			
			contrario = sj.getContrarioMasCerca(i);
			if(contrarioCubierto[contrario] == 1){
				ordenes[i][0] = 6;
				continue;
			}
				

			jug_mas_cerca = sj.getMiJugadorMasCerca(rival[contrario].getX(), rival[contrario].getY());			
			
			//System.out.println("Analizando defensa " + i + " m: " + m + " defensaX " + defensaX + " defensaY " + defensaY);
			
			if((jug_mas_cerca == i) || ((jug_mas_cerca <  N_DEFENSAS) && (jug_mas_cerca != 0))){
				if(rival[contrario].getX() < -30){
					defensaX = rival[contrario].getX() + 10;
					if(Math.abs(y) <= Math.abs(rival[contrario].getY())){					
						if(rival[contrario].getY() < 0)
							defensaY = rival[contrario].getY() + 10;
						else
							defensaY = rival[contrario].getY() - 10;					
					}else{					
						if(rival[i] .getY() > 0)
							defensaY = rival[contrario].getY() + 10;
						else
							defensaY = rival[contrario].getY() - 10;					
					}
				}
				ordenes[i][0] = 5;
				ordenes[i][1] = defensaX;
				ordenes[i][2] = defensaY;
				contrarioCubierto[contrario] = 1;				
			}
		}		
		//END Defensa
		
		
		//BEGIN MedioCampo		
		int medioIntersecta = 0;
		double distanciaMedioIntersecta = 1000;
		double intersectaMedioX = 0, intersectaMedioY = 0;
		double distanciaMedioActual1, distanciaMedioActual2;		
		double medioY = 0;
		double medioX = 0;		
		for(int i = N_DEFENSAS+1; i < N_DEFENSAS+1+N_CENTROS; i++){
			if(distancia((double)jugPos[i][0],(double)jugPos[i][1], jugador[i].getX(), jugador[i].getY()) > 30)
				ordenes[i][0] = 6;
			
			medioY = jugador[i].getY();
			medioX = jugador[i].getX();
			m = (anty-y)/(antx-x);
			if((Double.isNaN(m)) || (m == 0))
				m = 0;
			
			//interseccion en el eje Y
			if(m != 0)
				medioY = ((jugador[i].getX() - x) * m) + y;
			else
				medioY = y;
			
			//rebote en los laterales
			if(medioY < -120)
				medioY = 0-(120 +(medioY + 120));
			if(medioY > 120)
				medioY = 120 -(medioY - 120);
			
			distanciaMedioActual1 = distancia(jugador[i].getX(), jugador[i].getY(), jugador[i].getX(), medioY);
			
			//interseccion en el eje X				
			if(m != 0)
				medioX = ((jugador[i].getY() - y)/m)+x;
			else
				medioX = x;

			
			if(medioX > 60) 
				medioX = 10000;
			
			if(medioX < -15)
				medioX = 10000;
		

			distanciaMedioActual2 = distancia(jugador[i].getX(), jugador[i].getY(), medioX, jugador[i].getY());
			/*//System.out.println("Analizando medio " + i + " m: " + m + " medioX " + medioX + " medioY " + medioY);
			//System.out.println(" X " + jugador[i].getX() + " Y " + jugador[i].getY());
			//System.out.println(" distanciaMedio1: "+i + " = " +distanciaMedioActual1 + " distanciaMedio2: " + distanciaMedioActual2 +" actual " + distanciaMedioIntersecta);*/
			
			
			if(distanciaMedioActual2 < distanciaMedioActual1){
				if(distanciaMedioActual2 < distanciaMedioIntersecta){
					intersectaMedioX = jugador[i].getX();
					intersectaMedioY = medioY;
					distanciaMedioIntersecta = distanciaMedioActual2;
					medioIntersecta = i;
				}
			}else{
				if(distanciaMedioActual1 < distanciaMedioIntersecta){
					intersectaMedioX = medioX;
					intersectaMedioY = jugador[i].getY();
					distanciaMedioIntersecta = distanciaMedioActual1;
					medioIntersecta = i;
				}	
			}								
		
		}
		if((medioIntersecta != 0) && (distanciaMedioIntersecta < 100) 
		&& (intersectaMedioX <= 60) && (intersectaMedioX >= -15) 
		&& (intersectaMedioY <= 120) && (intersectaMedioY >= -120))  {
			ordenes[medioIntersecta][0] = 5;
			ordenes[medioIntersecta][1] = intersectaMedioX;
			ordenes[medioIntersecta][2] = intersectaMedioY;					
		}						
		

		//Si esta demasiado cerca de un rival se mueve alejandose
		for(int i = N_DEFENSAS+1; i < N_DEFENSAS+1+N_CENTROS; i++){
			if(i == medioIntersecta)
				continue;
			
			if(distancia((double)jugPos[i][0],(double)jugPos[i][1], jugador[i].getX(), jugador[i].getY()) < 35){
				contrario = sj.getContrarioMasCerca(i);
				if(distancia(rival[contrario].getX(),rival[contrario].getY(),jugador[i].getX(),jugador[i].getY()) < 16){
					ordenes[i][0] = 5;
					if(rival[contrario].getX() > x)					
						ordenes[i][1] = rival[contrario].getX() - 16;
					else
						ordenes[i][1] = rival[contrario].getX() + 16;
					
					if(rival[contrario].getY() > y)
						ordenes[i][2] = rival[contrario].getY() - 16;
					else
						ordenes[i][2] = rival[contrario].getY() + 16;					
				}
			}
					
		}		
		//END MedioCampo
		
		
		//BEGIN delantera
		int delanteraIntersecta = 0;
		double distanciadelanteraIntersecta = 1000;
		double intersectaDelanteraX = 0, intersectaDelanteraY = 0;
		double distanciadelanteraActual1, distanciadelanteraActual2;		
		double delanteraY = 0;
		double delanteraX = 0;

			
		for(int i = 7; i < 10; i++){			
			if(distancia((double)jugPos[i][0],(double)jugPos[i][1], jugador[i].getX(), jugador[i].getY()) > 20)
				ordenes[i][0] = 6;
			
			delanteraY = jugador[i].getY();
			delanteraX = jugador[i].getX();
			m = (anty-y)/(antx-x);
			if((Double.isNaN(m)) || (m == 0))
				m = 0;
			
			//interseccion en el eje Y
			if(m != 0)
				delanteraY = ((jugador[i].getX() - x) * m) + y;
			else
				delanteraY = y;
			
			//rebote en los laterales
			if(delanteraY < -120)
				delanteraY = 0-(120 +(delanteraY + 120));
			if(delanteraY > 120)
				delanteraY = 120 -(delanteraY - 120);
			
			distanciadelanteraActual1 = distancia(jugador[i].getX(), jugador[i].getY(), jugador[i].getX(), delanteraY);
			
			//interseccion en el eje X				
			if(m != 0)
				delanteraX = ((jugador[i].getY() - y)/m)+x;
			else
				delanteraX = x;

			
			if(delanteraX > 60) 
				delanteraX = 10000;
			
			if(delanteraX < -15)
				delanteraX = 10000;
		

			distanciadelanteraActual2 = distancia(jugador[i].getX(), jugador[i].getY(), delanteraX, jugador[i].getY());
			//System.out.println("Analizando delantera " + i + " m: " + m + " delanteraX " + delanteraX + " delanteraY " + delanteraY);
			//System.out.println(" X " + jugador[i].getX() + " Y " + jugador[i].getY());
			//System.out.println(" distanciadelantera1: "+i + " = " +distanciadelanteraActual1 + " distanciadelantera2: " + distanciadelanteraActual2 +" actual " + distanciadelanteraIntersecta);
			
			
			if(distanciadelanteraActual2 < distanciadelanteraActual1){
				if(distanciadelanteraActual2 < distanciadelanteraIntersecta){
					intersectaDelanteraX = jugador[i].getX();
					intersectaDelanteraY = delanteraY;
					distanciadelanteraIntersecta = distanciadelanteraActual2;
					delanteraIntersecta = i;
				}
			}else{
				if(distanciadelanteraActual1 < distanciadelanteraIntersecta){
					intersectaDelanteraX = delanteraX;
					intersectaDelanteraY = jugador[i].getY();
					distanciadelanteraIntersecta = distanciadelanteraActual1;
					delanteraIntersecta = i;
				}	
			}								
		
		}
		if((delanteraIntersecta != 0) && (distanciadelanteraIntersecta < 100) 
		&& (intersectaDelanteraX <= 60) && (intersectaDelanteraX >= -15) 
		&& (intersectaDelanteraY <= 120) && (intersectaDelanteraY >= -120))  {
			ordenes[delanteraIntersecta][0] = 5;
			ordenes[delanteraIntersecta][1] = intersectaDelanteraX;
			ordenes[delanteraIntersecta][2] = intersectaDelanteraY;					
		}						
		
		//Si esta demasiado cerca de un rival se mueve alejandose
		for(int i = 7; i < 10; i++){			
			if(i == delanteraIntersecta)
				continue;
			
			if(distancia((double)jugPos[i][0],(double)jugPos[i][1], jugador[i].getX(), jugador[i].getY()) < 25){
				contrario = sj.getContrarioMasCerca(i);
				if(distancia(rival[contrario].getX(),rival[contrario].getY(),jugador[i].getX(),jugador[i].getY()) < 16){
					ordenes[i][0] = 5;
					if(rival[contrario].getX() > x)					
						ordenes[i][1] = rival[contrario].getX() - 10;
					else
						ordenes[i][1] = rival[contrario].getX() + 10;
					
					if(rival[contrario].getY() > y)
						ordenes[i][2] = rival[contrario].getY() - 10;
					else
						ordenes[i][2] = rival[contrario].getY() + 10;					
				}
			}
					
		}	

		if(x < 120){
			double distanciaDelanteroSelecionado = 1000;
			int delanteroSeleccionado = 0;
		
			for(int i = 7; i < 10; i++){
				if(distanciaDelanteroSelecionado < distancia(jugador[i].getX(), jugador[i].getY(), x, y)){
					distanciaDelanteroSelecionado = distancia(jugador[i].getX(), jugador[i].getY(), x, y);
					delanteroSeleccionado = i;
				}
			}
			
			if(delanteroSeleccionado != 0){
				ordenes[delanteroSeleccionado][0] = 5;
				ordenes[delanteroSeleccionado][1] = x;
				ordenes[delanteroSeleccionado][2] = y;
			}
		}
		//END delantera
		
		
		
		//El mas cercano a la bola va a buscarla 
		int cercaJug=sj.getMasCercanoDeBola();
		
		if((cercaJug != 0) && (cercaJug != 10)){			
			ordenes[cercaJug][0] = 5;			
			ordenes[cercaJug][1] = x;
			ordenes[cercaJug][2] = y;			
		}
		
		//Los jugadores que estan cerca de la pelota miran a ver a quien pasan 
		for(int i = 0; i < 11; i++){
			if(distancia(jugador[i].getX(),jugador[i].getY(), x, y) < 30){
				ordenes[i][1] = x;
				ordenes[i][2] = y;
				int jugN[]= {1,0,0,0,0,0,0,0,0,0,0};
				jugN[i] = 1;			
				int pasar = evaluarPase(cercaJug, jugN, 0, sj);
				if(pasar== -1)
					ordenes[i][0] = 3;
				else{
					ordenes[i][0] = 4;
					ordenes[i][3] = pasar;
				}
			}			
		}	
		
		//bucle que ejecuta los comandos
		for(int i = 0; i < 11; i++){
			switch((int)ordenes[i][0]){
			case 0: comandos.add(new ComandoTiroAPuerta(i,0)); break;
			case 1: comandos.add(new ComandoGolpearBola(i,ordenes[i][1],ordenes[i][2])); break;
			case 2: comandos.add(new ComandoPase(i,(int)ordenes[i][1])); break;
			case 3: comandos.add(new ComandoIrA(i,ordenes[i][1],ordenes[i][2])); 
				comandos.add(new ComandoTiroAPuerta(i,0));
				break;
			case 4: comandos.add(new ComandoIrA(i,ordenes[i][1],ordenes[i][2])); 
				comandos.add(new ComandoPase(i,(int)ordenes[i][3]));
				break;
			case 5: comandos.add(new ComandoIrA(i,ordenes[i][1],ordenes[i][2])); break;
			case 6: comandos.add(new ComandoIrA(i,jugPos[i][0],jugPos[i][1])); break;
			default: break;	
			}
		}
		
			
		//System.out.println("antx: " + antx + " x: " + x + " anty: " + anty + " y: " + y + " vel: " + vel + " m: " +m);
		//System.out.println("porteroX: " + porteroX + " porteroY: " + porteroY);
		//System.out.println("defensaIntersecta: " + defensaIntersecta + " intersectaX: " + intersectaX + " intersectaY: " + intersectaY);
		//System.out.println("******************************************");		
		
	
		antx = x;
		anty = y;
       
		return comandos;
	}
    
	
    
	private double distancia(double x1, double y1,double x2, double y2){
	    return Math.sqrt(Math.pow(x1 - x2,2)  + Math.pow(y1 - y2, 2));	
	}
	
	
	//Devuelve el numero de jugador al que pasar -1 indica tirar a puerta
	private int evaluarPase(int jug, int jugN[], int profundidad, SituacionJugadores sj){
		Point[] jugador = sj.getMisJugadores();
		Point[] rival = sj.getContrario();
		
		jugN[jug] = 1;

		int jugSeleccionado = -1;		
		double paseX, paseY, x, y;
		int disMinima = distanciaMinima(jug);
		int disMaxima = distanciaMaxima(jug);
		int rivalCerca;
		double disPase = 0, disXPase = 0, distanciaRival = 0, disXJugSeleccionado = 0, distanciaRivalJugSeleccionado = 0;
		x = jugador[jug].getX();
		y = jugador[jug].getY();
		
		int valor = 0, valorJugSeleccionado = 0; 
		
		
		//si esta cerca de puerta tira a gol
		if((distancia(x,y,160,30) <= disMinima) || (distancia(x,y,160,-30) <= disMinima) || (distancia(x,y,160,0) <= disMinima)){
			int resultado = -1;
			return resultado;
		}
			
		
		for(int i =1; i < 10; i++){
			valor = 0;
			if(jugN[i] == 1)
				continue;
			
			paseX = jugador[i].getX();
			paseY = jugador[i].getY();
			disPase = distancia(x,y,paseX,paseY);
			
			disXPase = paseX-x;
			//si esta demasiado cerca no se le pasa
			if(disPase < disMinima)
				continue;
			
			if(disPase < disMaxima){				
				if(x < paseX){
					valor++;
					if(disXPase >= 60)
						valor++;
				}
			}			
			
			rivalCerca = sj.getContrarioMasCerca(i);
			distanciaRival = distancia(rival[rivalCerca].getX(),rival[rivalCerca].getY(),paseX,paseY);
			if(distanciaRival > 16){
				valor++;				
			}
			
			if(valor > valorJugSeleccionado){
				jugSeleccionado = i;
				valorJugSeleccionado = valor;
				disXJugSeleccionado = disXPase;
			}else{
				if((valor == valorJugSeleccionado) && ((disXPase+(2*distanciaRival)) > (disXJugSeleccionado+(2*distanciaRivalJugSeleccionado)))){
					jugSeleccionado = i;
					valorJugSeleccionado = valor;
					disXJugSeleccionado = disXPase;
				}
			}
			
			
			
			
		}
		
		return jugSeleccionado;

		
	}
	
	//distancia a la que le disparo es menor que 15
	private int distanciaMinima(int jug){
		switch(fuerza[jug]){
			case 4: return 0; 
			case 5: return 0; 
			case 6: return 51; 
			case 7: return 111; 
		}
		return 0;
	}
	
	//distancia hasta la que el disparo es mayor que 7
	private int distanciaMaxima(int jug){
		switch(fuerza[jug]){
			case 4: return 57; 
			case 5: return 99; 
			case 6: return 150; 
			case 7: return 210; 
		}
		return 0;
	}
	
}